…layInRect spam

The hasUsableHost guards added in the previous commit got us about halfway. On macOS 26 (Tahoe) I discovered later on that WindowServer was still logging _CGXPackagesSetWindowConstraints: Invalid window at roughly 3.9 hits/sec whenever widgets were visible, and lldb pointed at why: every spam line originated from a widget calling needsDisplay = true/display() inside its status-item button, not from anything the hasUsableHost guards covered.

The actual chain is that NSView.setNeedsDisplayInRect: now posts a CoreFoundation notification on every view invalidation. NSStatusBarWindow observes that notification on Tahoe and responds by calling NSStatusItem._windowNeedsReplicantUpdate:, which pushes a window-geometry constraint to SkyLight via _CGXPackagesSetWindowConstraints. If the status item's backing window is in any transitional state at that moment (which is much more frequent on Tahoe due to menu bar overflow, the notch, and Liquid Glass animation), SkyLight logs Invalid window and drops the request. Every widget redraw round-trips through WindowServer regardless of whether NSStatusItem.length is ever touched, and swapping display() for needsDisplay = true does nothing because both end up at setNeedsDisplayInRect: internally.

This change replaces the AppKit invalidation path with a layer-contents pipeline. Each WidgetWrapper now sets wantsLayer = true at init and gains a renderToLayer() method that renders the widget's existing draw(_:) output off-screen into a CGContext-backed CGImage and assigns it directly to layer.contents inside a CATransaction with implicit animations disabled. The notification chain never fires because setNeedsDisplayInRect: is never called.

Call sites that previously triggered redraws are swapped accordingly:

- Every needsDisplay = true and display() call in Mini, Memory, Speed, Battery, Dot, LineChart, BarChart, NetworkChart, Stack, and Text widgets now calls renderToLayer() instead.

- Charts.displayIfVisible and the CombinedView paths swap the same way.

- WidgetWrapper.redraw() is now main-thread-aware and dispatches renderToLayer().

- The widget re-renders on viewDidMoveToWindow and viewDidChangeEffectiveAppearance so its contents are correct after host changes or appearance shifts.

The hasUsableHost guards and the previous commit's idempotent addSubview behaviour are retained. They're independent of this change and still useful for skipping work when the status item isn't hosted yet. A new attachToMenuBar(retries:) helper on SWidget and configureMenuBarButton(retries:) on MenuBar replace the inline status-bar setup so the bind-to-button work waits for a valid backing window instead of firing immediately on creation.

Measured on macOS 26.5 over a 10h run with all modules active: pre-fix WindowServer was logging the spam at ~3.9 hits/sec sustained whenever Stats was visible. Post-fix: 0.025 hits/sec during active use, 0.006 hits/sec idle, with two small launch-time bursts of ~5 hits each before the renderToLayer pipeline takes over. That's a ~150x reduction during active use and ~650x idle. Stats itself stays flat at 0% CPU and ~64 MB RSS over the run.

…uards

# Conflicts:
#	Kit/Widgets/LineChart.swift
#	Kit/Widgets/Memory.swift
#	Kit/Widgets/Mini.swift
#	Kit/Widgets/NetworkChart.swift

Four fixes to the layer-contents pipeline:

- Override viewDidChangeBackingProperties on WidgetWrapper to call renderToLayer(). Without this the cached layer.contents image stays at its previous scale when the widget moves between displays of different DPI (like disconnecting a Retina external), leaving widgets blurry or oversharp until the next setValue tick refreshes them.

- Set layerContentsRedrawPolicy = .never. Without this the default .duringViewResize policy lets AppKit autonomously call draw(_:) on view geometry changes (which happen often when text widgets re-measure on each value update), going through setNeedsDisplayInRect: and re-triggering the notification chain renderToLayer is meant to bypass. Setting .never tells AppKit the application owns layer contents entirely.

- Switch contentsGravity from .resize to .center. The transient frame between a resize and the next renderToLayer call is normally a single frame, but .resize stretches the cached image to fill the new bounds, which looks obviously wrong for text widgets during that frame. .center shows the old image at natural size (possibly clipped) which reads correctly.

- Switch the CGContext pixel format from premultipliedLast (RGBA) to premultipliedFirst + byteOrder32Little (BGRA). BGRA is the native pixel layout for CoreGraphics and CoreAnimation on Apple platforms, so handing the CGImage to layer.contents no longer requires a swizzle pass before GPU upload. The perf difference is in the low microseconds for a status bar widget redrawing at ~1 Hz so it's not measurable in practice, but it matches the native pixel layout used by IOSurface and CoreAnimation.